home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / game / misc / videopokeri_sr.lha / SoundInit.c < prev    next >
C/C++ Source or Header  |  1995-02-03  |  10KB  |  344 lines
  1.  
  2. /***********************************************************************
  3.  *                                                                     *
  4.  *  Headerfile   : SoundInit.c                                         *
  5.  *                                                                     *
  6.  *  Program      : VIDEO-POKERI                                        *
  7.  *                                                                     *
  8.  *  Version      : 1.02       (05.11.1991)   (03.02.1995)              *
  9.  *                                                                     *
  10.  *  Author       : JanTAki                                             *
  11.  *                 92100  RAAHE ,  FINLAND                             *
  12.  *                                                                     *
  13.  *  E-mail       : janta@ratol.fi                                      *
  14.  *                                                                     *
  15.  ***********************************************************************/
  16.  
  17.  
  18. /* AvaaSoundit */
  19.  
  20. #include <exec/types.h>
  21. #include <devices/audio.h>
  22. #include <libraries/dos.h>
  23. #include <exec/memory.h>
  24. #include <proto/exec.h>
  25. #include <clib/dos_protos.h>
  26.  
  27. #define MakeID(a,b,c,d) ((a)<<24L | (b)<<16L | (c)<<8 | (d))
  28.  
  29. #define ID_FORM MakeID('F','O','R','M')
  30.  
  31. #define ID_8SVX MakeID('8','S','V','X')
  32. #define ID_VHDR MakeID('V','H','D','R')
  33. #define ID_BODY MakeID('B','O','D','Y')
  34.  
  35. #define SOUND_MAX 11          /* Soundien lukumäärä */
  36.  
  37. extern  UBYTE   stringi[];
  38. extern  UBYTE   BON[] ;
  39. extern  UBYTE   OFF[] ;
  40. extern  UBYTE   COL1[];
  41. extern  UBYTE   COL2[];
  42. extern  UBYTE   SS;
  43. extern  UBYTE   SOUNDS;
  44.  
  45. extern  VOID cleanExit(SHORT);
  46. extern  ULONG clock;
  47.  
  48. VOID    AvaaSoundit(VOID);
  49. VOID    VaraaKanavat(VOID);
  50. VOID    Sound(SHORT, SHORT, SHORT);
  51.  
  52. struct Chunk
  53. {
  54.    LONG  ckID;
  55.    LONG  ckSize;
  56. };
  57.  
  58. struct Chunk *p8chunk;
  59.  
  60. UBYTE  *sbase[SOUND_MAX];
  61. ULONG   speed[SOUND_MAX];
  62. ULONG   ssize[SOUND_MAX];
  63. extern  struct  IOAudio     *AIOptr1, *AIOptr2;
  64. extern  struct  MsgPort     *port1;
  65. extern  struct  MsgPort     *port2;
  66. extern  ULONG   device1, device2;
  67.  
  68. VOID AvaaSoundit()
  69. {
  70. struct  FileHandle  *v8handle;
  71. SHORT   lask;
  72. BYTE    iobuffer[8];
  73. UBYTE  *fname[] = { "Sounds/HoldON.8svx",
  74.                     "Sounds/HoldOFF.8svx",
  75.                     "Sounds/Bet.8svx",
  76.                     "Sounds/Counting.8svx",
  77.                     "Sounds/DoubleOK.8svx",
  78.                     "Sounds/DoubleFail.8svx",
  79.                     "Sounds/CardOFF.8svx",
  80.                     "Sounds/Deal.8svx",
  81.                     "Sounds/GameOver.8svx",
  82.                     "Sounds/DoubleStart.8svx",
  83.                     "Sounds/BigWin.8svx"
  84.                      };
  85.  
  86.  
  87. UBYTE  *fbase;
  88. UBYTE  *p8data;
  89. SHORT   freq;
  90. ULONG   rd8count;
  91. UBYTE  *pointer;
  92. ULONG   fsize;
  93. BYTE   *psample[SOUND_MAX];
  94.  
  95. sbase[0]    = 0L;
  96. sbase[1]    = 0L;
  97. sbase[2]    = 0L;
  98.  
  99. for(lask=0; lask<SOUND_MAX; lask++)       /* ladataan samplet */
  100. {
  101.  
  102. v8handle= (struct FileHandle *) Open(fname[lask], MODE_OLDFILE);
  103. if (v8handle==0)
  104.     {
  105.     cleanExit(11);      /* soundi-tiedosto ei aukea */
  106.     }
  107.  
  108. rd8count = Read((BPTR)v8handle, iobuffer, 8L);
  109. if (rd8count==-1)
  110.     {
  111.     cleanExit(11);      /* lukuvirhe */
  112.     }
  113. if (rd8count<8)
  114.     {
  115.     cleanExit(11);      /* lyhyt -> ei IFF */
  116.     }
  117.  
  118. p8chunk = (struct Chunk *)iobuffer;
  119. if (p8chunk->ckID != ID_FORM)
  120.     {
  121.     cleanExit(12);
  122.     }
  123.  
  124. fbase = (UBYTE *)AllocMem(fsize = p8chunk->ckSize, MEMF_PUBLIC | MEMF_CLEAR);
  125.     if (fbase==0)
  126.     {
  127.     cleanExit(9);
  128.     }
  129.         
  130. p8data = fbase;
  131.  
  132. rd8count = Read( (BPTR)v8handle, p8data, p8chunk->ckSize );
  133. if (rd8count==-1)
  134.     {
  135.     cleanExit(11);
  136.     }
  137. if (rd8count<p8chunk->ckSize)
  138.     {
  139.     cleanExit(11);
  140.     }
  141.  
  142. if ( MakeID(*p8data, *(p8data+1), *(p8data+2), *(p8data+3) ) != ID_8SVX )
  143.     {
  144.     cleanExit(12);
  145.     }
  146.  
  147.     p8data += 4;
  148.     while (p8data < fbase+fsize)
  149.         {
  150.         p8chunk = (struct Chunk *)p8data;
  151.         pointer = (UBYTE *)&(p8chunk->ckID);
  152.  
  153.         switch (p8chunk->ckID)
  154.             {
  155.             case ID_VHDR:
  156.                 freq = (SHORT)*(SHORT *)(pointer+20);
  157.                 break;
  158.             case ID_BODY:
  159.                     ssize[lask] = (ULONG)*(ULONG *)(pointer+4);
  160.                     psample[lask] = (BYTE *)(p8data+8L);
  161.                 break;
  162.             default:
  163.                 break;
  164.             }
  165.         p8data = p8data + 8L + p8chunk->ckSize;
  166.         if (p8chunk->ckSize&1L == 1)
  167.             p8data++;
  168.         }
  169.  
  170.     sbase[lask] = (UBYTE *)AllocMem(ssize[lask], MEMF_CHIP | MEMF_CLEAR);   
  171.     if (sbase[lask]==0)
  172.         {
  173.         cleanExit(9);
  174.         }
  175.  
  176.     CopyMem(psample[lask], sbase[lask], ssize[lask]);
  177.  
  178.     if (fbase != 0)  FreeMem(fbase, fsize);
  179.     if (v8handle != 0)  Close((BPTR)v8handle); 
  180.  
  181.     speed[lask] = clock / freq;
  182.  
  183. }
  184.  
  185. }
  186.  
  187.  
  188. VOID VaraaKanavat()
  189. {
  190. UBYTE   chans1[]  = { 1, 8, 2, 4 };
  191. UBYTE   chans2[]  = { 2, 4, 1, 8 };
  192.  
  193.     AIOptr1 = (struct IOAudio *) AllocMem( sizeof(struct IOAudio),
  194.         MEMF_CHIP | MEMF_PUBLIC | MEMF_CLEAR);
  195.     if (AIOptr1 == 0)
  196.         {
  197.         cleanExit(9);
  198.         }
  199.  
  200.     AIOptr2 = (struct IOAudio *) AllocMem( sizeof(struct IOAudio),
  201.         MEMF_CHIP | MEMF_PUBLIC | MEMF_CLEAR);
  202.     if (AIOptr2 == 0)
  203.         {
  204.         cleanExit(9);
  205.         }
  206.  
  207.     port1 = CreatePort(0, 0);
  208.     if (port1 == 0)
  209.         {
  210.         cleanExit(13);
  211.         }
  212.  
  213.     port2 = CreatePort(0, 0);
  214.     if (port2 == 0)
  215.         {
  216.         cleanExit(13);
  217.         }
  218.  
  219.         AIOptr1->ioa_Request.io_Message.mn_ReplyPort    = port1;
  220.         AIOptr1->ioa_Request.io_Message.mn_Node.ln_Pri  = 40;
  221.         AIOptr1->ioa_Request.io_Command                 = ADCMD_ALLOCATE;
  222.         AIOptr1->ioa_AllocKey                           = 0;
  223.         AIOptr1->ioa_Data                               = chans1;
  224.         AIOptr1->ioa_Length                             = sizeof(chans1);
  225.  
  226.         device1 = OpenDevice("audio.device", 0L,
  227.             (struct IORequest *)AIOptr1, 0L);
  228.  
  229.     if (device1!=0)
  230.         {
  231.         cleanExit(14);
  232.         }
  233.  
  234.         AIOptr2->ioa_Request.io_Message.mn_ReplyPort    = port2;
  235.         AIOptr2->ioa_Request.io_Message.mn_Node.ln_Pri  = 40;
  236.         AIOptr2->ioa_Request.io_Command                 = ADCMD_ALLOCATE;
  237.         AIOptr2->ioa_AllocKey                           = 0;
  238.         AIOptr2->ioa_Data                               = chans2;
  239.         AIOptr2->ioa_Length                             = sizeof(chans2);
  240.         device2 = OpenDevice("audio.device", 0L,
  241.             (struct IORequest *)AIOptr2, 0L);
  242.  
  243.     if (device2!=0)
  244.         {
  245.         cleanExit(14);
  246.         }
  247.  
  248. }
  249.  
  250.  
  251. VOID Sound(index, time, channel)
  252. SHORT index, time, channel;
  253.                     /* time == 0 --> normaali näytetaajuus!! */
  254.                     /* time <> 0 --> time = näytetaajuus!!   */
  255.                     /* time >  100 --> nopeampi / korkeampi    */
  256. {
  257.  
  258. if (SOUNDS == 0)    /* SOUNDIT VAIN JOS NE ON PÄÄLLÄ ! ( == 0 ) */
  259. {
  260. if (index > SOUND_MAX-1 || index < 0)
  261.     {
  262.     index = 0;      /* ulkona -> ääni nolla */
  263.     }
  264.  
  265. switch (channel)
  266.     {
  267.     case 0:             /* vasen / oikea vuorotellen */
  268.         if (SS == 1)
  269.             {
  270.             AIOptr1->ioa_Request.io_Command = CMD_WRITE;
  271.             AIOptr1->ioa_Request.io_Flags   = ADIOF_PERVOL;
  272.             AIOptr1->ioa_Volume             = 64;
  273.             AIOptr1->ioa_Period     = (UWORD)speed[index]-(100-time);
  274.             AIOptr1->ioa_Cycles             = 1;
  275.             AIOptr1->ioa_Data               = (UBYTE *)sbase[index];
  276.             AIOptr1->ioa_Length             = ssize[index];
  277.             SS=2;
  278.             AbortIO( (struct IORequest *)AIOptr1);
  279.             BeginIO( (struct IORequest *)AIOptr1);
  280.             }
  281.         else
  282.             {
  283.             AIOptr2->ioa_Request.io_Command = CMD_WRITE;
  284.             AIOptr2->ioa_Request.io_Flags   = ADIOF_PERVOL;
  285.             AIOptr2->ioa_Volume             = 64;
  286.             AIOptr2->ioa_Period     = (UWORD)speed[index]-(100-time);
  287.             AIOptr2->ioa_Cycles             = 1;
  288.             AIOptr2->ioa_Data               = (UBYTE *)sbase[index];
  289.             AIOptr2->ioa_Length             = ssize[index];
  290.             SS=1;
  291.             AbortIO( (struct IORequest *)AIOptr2);
  292.             BeginIO( (struct IORequest *)AIOptr2);
  293.             }
  294.         break;
  295.     case 1:                 /* vasen kanava */
  296.         AIOptr2->ioa_Request.io_Command = CMD_WRITE;
  297.         AIOptr2->ioa_Request.io_Flags   = ADIOF_PERVOL;
  298.         AIOptr2->ioa_Volume             = 64;
  299.         AIOptr2->ioa_Period         = (UWORD)speed[index]-(100-time);
  300.         AIOptr2->ioa_Cycles             = 1;
  301.         AIOptr2->ioa_Data               = (UBYTE *)sbase[index];
  302.         AIOptr2->ioa_Length             = ssize[index];
  303.             AbortIO( (struct IORequest *)AIOptr2);
  304.             BeginIO( (struct IORequest *)AIOptr2);
  305.         break;
  306.     case 2:                 /* oikea kanava */
  307.         AIOptr1->ioa_Request.io_Command = CMD_WRITE;
  308.         AIOptr1->ioa_Request.io_Flags   = ADIOF_PERVOL;
  309.         AIOptr1->ioa_Volume             = 64;
  310.         AIOptr1->ioa_Period         = (UWORD)speed[index]-(100-time);
  311.         AIOptr1->ioa_Cycles             = 1;
  312.         AIOptr1->ioa_Data               = (UBYTE *)sbase[index];
  313.         AIOptr1->ioa_Length             = ssize[index];
  314.             AbortIO( (struct IORequest *)AIOptr1);
  315.             BeginIO( (struct IORequest *)AIOptr1);
  316.         break;
  317.     case 3:             /* vakiokanava: stereo  */
  318.     default:
  319.         AIOptr1->ioa_Request.io_Command = CMD_WRITE;
  320.         AIOptr1->ioa_Request.io_Flags   = ADIOF_PERVOL;
  321.         AIOptr1->ioa_Volume             = 64;
  322.         AIOptr1->ioa_Period         = (UWORD)speed[index]-(100-time);
  323.         AIOptr1->ioa_Cycles             = 1;
  324.         AIOptr1->ioa_Data               = (UBYTE *)sbase[index];
  325.         AIOptr1->ioa_Length             = ssize[index];
  326.  
  327.         AIOptr2->ioa_Request.io_Command = CMD_WRITE;
  328.         AIOptr2->ioa_Request.io_Flags   = ADIOF_PERVOL;
  329.         AIOptr2->ioa_Volume             = 64;
  330.         AIOptr2->ioa_Period         = (UWORD)speed[index]-(100-time);
  331.         AIOptr2->ioa_Cycles             = 1;
  332.         AIOptr2->ioa_Data               = (UBYTE *)sbase[index];
  333.         AIOptr2->ioa_Length             = ssize[index];
  334.             AbortIO( (struct IORequest *)AIOptr1);
  335.             AbortIO( (struct IORequest *)AIOptr2);
  336.             BeginIO( (struct IORequest *)AIOptr1);
  337.             BeginIO( (struct IORequest *)AIOptr2);
  338.         break;
  339.     }
  340. }   /* END OF [ if (SOUNDS == 0) ... ] */
  341.  
  342. }
  343.  
  344. /* end of SoundInit.c */